home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1995 August: Tool Chest / Dev.CD Aug 95 TC / Dev.CD Aug 95 TC.toast / Tool Chest / Interfaces / UniversalInterfaces 2.0 / PInterfaces / Slots.p < prev    next >
Encoding:
Text File  |  1995-04-18  |  12.3 KB  |  397 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        Slots.p
  3.  
  4.      Contains:    Slot Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.0 in “MPW Latest” on ETO #17
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT Slots;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __SLOTS__}
  30. {$SETC __SLOTS__ := 1}
  31.  
  32. {$I+}
  33. {$SETC SlotsIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __TYPES__}
  38. {$I Types.p}
  39. {$ENDC}
  40. {    ConditionalMacros.p                                            }
  41.  
  42. {$IFC UNDEFINED __EVENTS__}
  43. {$I Events.p}
  44. {$ENDC}
  45. {    Quickdraw.p                                                    }
  46. {        MixedMode.p                                                }
  47. {        QuickdrawText.p                                            }
  48. {    OSUtils.p                                                    }
  49. {        Memory.p                                                }
  50.  
  51. {$IFC UNDEFINED __OSUTILS__}
  52. {$I OSUtils.p}
  53. {$ENDC}
  54.  
  55. {$IFC UNDEFINED __FILES__}
  56. {$I Files.p}
  57. {$ENDC}
  58.  
  59. {$PUSH}
  60. {$ALIGN MAC68K}
  61. {$LibExport+}
  62.  
  63. CONST
  64.     fCardIsChanged                = 1;                            {Card is Changed field in StatusFlags field of sInfoArray}
  65.     fCkForSame                    = 0;                            {For SearchSRT. Flag to check for SAME sResource in the table. }
  66.     fCkForNext                    = 1;                            {For SearchSRT. Flag to check for NEXT sResource in the table. }
  67.     fWarmStart                    = 2;                            {If this bit is set then warm start else cold start.}
  68.     stateNil                    = 0;                            {State}
  69.     stateSDMInit                = 1;                            {:Slot declaration manager Init}
  70.     statePRAMInit                = 2;                            {:sPRAM record init}
  71.     statePInit                    = 3;                            {:Primary init}
  72.     stateSInit                    = 4;                            {:Secondary init}
  73. { flags for spParamData }
  74.     fall                        = 0;                            { bit 0: set=search enabled/disabled sRsrc's }
  75.     foneslot                    = 1;                            {    1: set=search sRsrc's in given slot only }
  76.     fnext                        = 2;                            {    2: set=search for next sRsrc }
  77.  
  78. TYPE
  79.     {
  80.         SlotIntServiceProcPtr uses register based parameters on the 68k and cannot
  81.         be written in or called from a high-level language without the help of
  82.         mixed mode or assembly glue.
  83.  
  84.         In:
  85.          => sqParameter     A1.L
  86.         Out:
  87.          <= return value    D0.W
  88.     }
  89.     SlotIntServiceProcPtr = Register68kProcPtr;  { register FUNCTION SlotIntService(sqParameter: LONGINT): INTEGER; }
  90.     SlotIntServiceUPP = UniversalProcPtr;
  91.  
  92. CONST
  93.     uppSlotIntServiceProcInfo = $0000B822; { Register FUNCTION (4 bytes in A1): 2 bytes in D0; }
  94.  
  95. FUNCTION NewSlotIntServiceProc(userRoutine: SlotIntServiceProcPtr): SlotIntServiceUPP;
  96.     {$IFC NOT GENERATINGCFM }
  97.     INLINE $2E9F;
  98.     {$ENDC}
  99.  
  100. FUNCTION CallSlotIntServiceProc(sqParameter: LONGINT; userRoutine: SlotIntServiceUPP): INTEGER;
  101.     {$IFC NOT GENERATINGCFM}
  102.     {To be implemented:  Glue to move parameters into registers.}
  103.     {$ENDC}
  104.  
  105. TYPE
  106.     SlotIntQElement = RECORD
  107.         sqLink:                    Ptr;                                    {ptr to next element}
  108.         sqType:                    INTEGER;                                {queue type ID for validity}
  109.         sqPrio:                    INTEGER;                                {priority}
  110.         sqAddr:                    SlotIntServiceUPP;                        {interrupt service routine}
  111.         sqParm:                    LONGINT;                                {optional A1 parameter}
  112.     END;
  113.  
  114.     SQElemPtr = ^SlotIntQElement;
  115.  
  116.     SpBlock = RECORD
  117.         spResult:                LONGINT;                                {FUNCTION Result}
  118.         spsPointer:                Ptr;                                    {structure pointer}
  119.         spSize:                    LONGINT;                                {size of structure}
  120.         spOffsetData:            LONGINT;                                {offset/data field used by sOffsetData}
  121.         spIOFileName:            Ptr;                                    {ptr to IOFile name for sDisDrvrName}
  122.         spsExecPBlk:            Ptr;                                    {pointer to sExec parameter block.}
  123.         spParamData:            LONGINT;                                {misc parameter data (formerly spStackPtr).}
  124.         spMisc:                    LONGINT;                                {misc field for SDM.}
  125.         spReserved:                LONGINT;                                {reserved for future expansion}
  126.         spIOReserved:            INTEGER;                                {Reserved field of Slot Resource Table}
  127.         spRefNum:                INTEGER;                                {RefNum}
  128.         spCategory:                INTEGER;                                {sType: Category}
  129.         spCType:                INTEGER;                                {Type}
  130.         spDrvrSW:                INTEGER;                                {DrvrSW}
  131.         spDrvrHW:                INTEGER;                                {DrvrHW}
  132.         spTBMask:                SInt8;                                    {type bit mask bits 0..3 mask words 0..3}
  133.         spSlot:                    SInt8;                                    {slot number}
  134.         spID:                    SInt8;                                    {structure ID}
  135.         spExtDev:                SInt8;                                    {ID of the external device}
  136.         spHwDev:                SInt8;                                    {Id of the hardware device.}
  137.         spByteLanes:            SInt8;                                    {bytelanes from card ROM format block}
  138.         spFlags:                SInt8;                                    {standard flags}
  139.         spKey:                    SInt8;                                    {Internal use only}
  140.     END;
  141.  
  142.     SpBlockPtr = ^SpBlock;
  143.  
  144.     SInfoRecord = RECORD
  145.         siDirPtr:                Ptr;                                    {Pointer to directory}
  146.         siInitStatusA:            INTEGER;                                {initialization E}
  147.         siInitStatusV:            INTEGER;                                {status returned by vendor init code}
  148.         siState:                SInt8;                                    {initialization state}
  149.         siCPUByteLanes:            SInt8;                                    {0=[d0..d7] 1=[d8..d15]}
  150.         siTopOfROM:                SInt8;                                    {Top of ROM= $FssFFFFx: x is TopOfROM}
  151.         siStatusFlags:            SInt8;                                    {bit 0 - card is changed}
  152.         siTOConst:                INTEGER;                                {Time Out C for BusErr}
  153.         siReserved:                ARRAY [0..1] OF SInt8;                    {reserved}
  154.         siROMAddr:                Ptr;                                    { addr of top of ROM }
  155.         siSlot:                    SInt8;                                    { slot number }
  156.         siPadding:                ARRAY [0..2] OF SInt8;                    { reserved }
  157.     END;
  158.  
  159.     SInfoRecPtr = ^SInfoRecord;
  160.  
  161.     SDMRecord = RECORD
  162.         sdBEVSave:                ProcPtr;                                {Save old BusErr vector}
  163.         sdBusErrProc:            ProcPtr;                                {Go here to determine if it is a BusErr}
  164.         sdErrorEntry:            ProcPtr;                                {Go here if BusErrProc finds real BusErr}
  165.         sdReserved:                LONGINT;                                {Reserved}
  166.     END;
  167.  
  168.     FHeaderRec = RECORD
  169.         fhDirOffset:            LONGINT;                                {offset to directory}
  170.         fhLength:                LONGINT;                                {length of ROM}
  171.         fhCRC:                    LONGINT;                                {CRC}
  172.         fhROMRev:                SInt8;                                    {revision of ROM}
  173.         fhFormat:                SInt8;                                    {format - 2}
  174.         fhTstPat:                LONGINT;                                {test pattern}
  175.         fhReserved:                SInt8;                                    {reserved}
  176.         fhByteLanes:            SInt8;                                    {ByteLanes}
  177.     END;
  178.  
  179.     FHeaderRecPtr = ^FHeaderRec;
  180.  
  181.     SEBlock = PACKED RECORD
  182.         seSlot:                    UInt8;                                    {Slot number.}
  183.         sesRsrcId:                UInt8;                                    {sResource Id.}
  184.         seStatus:                INTEGER;                                {Status of code executed by sExec.}
  185.         seFlags:                UInt8;                                    {Flags}
  186.         seFiller0:                UInt8;                                    {Filler, must be SignedByte to align on odd boundry}
  187.         seFiller1:                UInt8;                                    {Filler}
  188.         seFiller2:                UInt8;                                    {Filler}
  189.         seResult:                LONGINT;                                {Result of sLoad.}
  190.         seIOFileName:            LONGINT;                                {Pointer to IOFile name.}
  191.         seDevice:                UInt8;                                    {Which device to read from.}
  192.         sePartition:            UInt8;                                    {The partition.}
  193.         seOSType:                UInt8;                                    {Type of OS.}
  194.         seReserved:                UInt8;                                    {Reserved field.}
  195.         seRefNum:                UInt8;                                    {RefNum of the driver.}
  196.         seNumDevices:            UInt8;                                    { Number of devices to load.}
  197.         seBootState:            UInt8;                                    {State of StartBoot code.}
  198.     END;
  199.  
  200. {  Principle  }
  201.  
  202. FUNCTION SReadByte(spBlkPtr: SpBlockPtr): OSErr;
  203.     {$IFC NOT GENERATINGCFM}
  204.     INLINE $205F, $7000, $A06E, $3E80;
  205.     {$ENDC}
  206. FUNCTION SReadWord(spBlkPtr: SpBlockPtr): OSErr;
  207.     {$IFC NOT GENERATINGCFM}
  208.     INLINE $205F, $7001, $A06E, $3E80;
  209.     {$ENDC}
  210. FUNCTION SReadLong(spBlkPtr: SpBlockPtr): OSErr;
  211.     {$IFC NOT GENERATINGCFM}
  212.     INLINE $205F, $7002, $A06E, $3E80;
  213.     {$ENDC}
  214. FUNCTION SGetCString(spBlkPtr: SpBlockPtr): OSErr;
  215.     {$IFC NOT GENERATINGCFM}
  216.     INLINE $205F, $7003, $A06E, $3E80;
  217.     {$ENDC}
  218. FUNCTION SGetBlock(spBlkPtr: SpBlockPtr): OSErr;
  219.     {$IFC NOT GENERATINGCFM}
  220.     INLINE $205F, $7005, $A06E, $3E80;
  221.     {$ENDC}
  222. FUNCTION SFindStruct(spBlkPtr: SpBlockPtr): OSErr;
  223.     {$IFC NOT GENERATINGCFM}
  224.     INLINE $205F, $7006, $A06E, $3E80;
  225.     {$ENDC}
  226. FUNCTION SReadStruct(spBlkPtr: SpBlockPtr): OSErr;
  227.     {$IFC NOT GENERATINGCFM}
  228.     INLINE $205F, $7007, $A06E, $3E80;
  229.     {$ENDC}
  230. {  Special  }
  231. FUNCTION SReadInfo(spBlkPtr: SpBlockPtr): OSErr;
  232.     {$IFC NOT GENERATINGCFM}
  233.     INLINE $205F, $7010, $A06E, $3E80;
  234.     {$ENDC}
  235. FUNCTION SReadPRAMRec(spBlkPtr: SpBlockPtr): OSErr;
  236.     {$IFC NOT GENERATINGCFM}
  237.     INLINE $205F, $7011, $A06E, $3E80;
  238.     {$ENDC}
  239. FUNCTION SPutPRAMRec(spBlkPtr: SpBlockPtr): OSErr;
  240.     {$IFC NOT GENERATINGCFM}
  241.     INLINE $205F, $7012, $A06E, $3E80;
  242.     {$ENDC}
  243. FUNCTION SReadFHeader(spBlkPtr: SpBlockPtr): OSErr;
  244.     {$IFC NOT GENERATINGCFM}
  245.     INLINE $205F, $7013, $A06E, $3E80;
  246.     {$ENDC}
  247. FUNCTION SNextSRsrc(spBlkPtr: SpBlockPtr): OSErr;
  248.     {$IFC NOT GENERATINGCFM}
  249.     INLINE $205F, $7014, $A06E, $3E80;
  250.     {$ENDC}
  251. FUNCTION SNextTypeSRsrc(spBlkPtr: SpBlockPtr): OSErr;
  252.     {$IFC NOT GENERATINGCFM}
  253.     INLINE $205F, $7015, $A06E, $3E80;
  254.     {$ENDC}
  255. FUNCTION SRsrcInfo(spBlkPtr: SpBlockPtr): OSErr;
  256.     {$IFC NOT GENERATINGCFM}
  257.     INLINE $205F, $7016, $A06E, $3E80;
  258.     {$ENDC}
  259. FUNCTION SCkCardStat(spBlkPtr: SpBlockPtr): OSErr;
  260.     {$IFC NOT GENERATINGCFM}
  261.     INLINE $205F, $7018, $A06E, $3E80;
  262.     {$ENDC}
  263. FUNCTION SReadDrvrName(spBlkPtr: SpBlockPtr): OSErr;
  264.     {$IFC NOT GENERATINGCFM}
  265.     INLINE $205F, $7019, $A06E, $3E80;
  266.     {$ENDC}
  267. FUNCTION SFindDevBase(spBlkPtr: SpBlockPtr): OSErr;
  268.     {$IFC NOT GENERATINGCFM}
  269.     INLINE $205F, $701B, $A06E, $3E80;
  270.     {$ENDC}
  271. FUNCTION SFindBigDevBase(spBlkPtr: SpBlockPtr): OSErr;
  272.     {$IFC NOT GENERATINGCFM}
  273.     INLINE $205F, $701C, $A06E, $3E80;
  274.     {$ENDC}
  275. {  Advanced  }
  276. FUNCTION InitSDeclMgr(spBlkPtr: SpBlockPtr): OSErr;
  277.     {$IFC NOT GENERATINGCFM}
  278.     INLINE $205F, $7020, $A06E, $3E80;
  279.     {$ENDC}
  280. FUNCTION SPrimaryInit(spBlkPtr: SpBlockPtr): OSErr;
  281.     {$IFC NOT GENERATINGCFM}
  282.     INLINE $205F, $7021, $A06E, $3E80;
  283.     {$ENDC}
  284. FUNCTION SCardChanged(spBlkPtr: SpBlockPtr): OSErr;
  285.     {$IFC NOT GENERATINGCFM}
  286.     INLINE $205F, $7022, $A06E, $3E80;
  287.     {$ENDC}
  288. FUNCTION SExec(spBlkPtr: SpBlockPtr): OSErr;
  289.     {$IFC NOT GENERATINGCFM}
  290.     INLINE $205F, $7023, $A06E, $3E80;
  291.     {$ENDC}
  292. FUNCTION SOffsetData(spBlkPtr: SpBlockPtr): OSErr;
  293.     {$IFC NOT GENERATINGCFM}
  294.     INLINE $205F, $7024, $A06E, $3E80;
  295.     {$ENDC}
  296. FUNCTION SInitPRAMRecs(spBlkPtr: SpBlockPtr): OSErr;
  297.     {$IFC NOT GENERATINGCFM}
  298.     INLINE $205F, $7025, $A06E, $3E80;
  299.     {$ENDC}
  300. FUNCTION SReadPBSize(spBlkPtr: SpBlockPtr): OSErr;
  301.     {$IFC NOT GENERATINGCFM}
  302.     INLINE $205F, $7026, $A06E, $3E80;
  303.     {$ENDC}
  304. FUNCTION SCalcStep(spBlkPtr: SpBlockPtr): OSErr;
  305.     {$IFC NOT GENERATINGCFM}
  306.     INLINE $205F, $7028, $A06E, $3E80;
  307.     {$ENDC}
  308. FUNCTION SInitSRsrcTable(spBlkPtr: SpBlockPtr): OSErr;
  309.     {$IFC NOT GENERATINGCFM}
  310.     INLINE $205F, $7029, $A06E, $3E80;
  311.     {$ENDC}
  312. FUNCTION SSearchSRT(spBlkPtr: SpBlockPtr): OSErr;
  313.     {$IFC NOT GENERATINGCFM}
  314.     INLINE $205F, $702A, $A06E, $3E80;
  315.     {$ENDC}
  316. FUNCTION SUpdateSRT(spBlkPtr: SpBlockPtr): OSErr;
  317.     {$IFC NOT GENERATINGCFM}
  318.     INLINE $205F, $702B, $A06E, $3E80;
  319.     {$ENDC}
  320. FUNCTION SCalcSPointer(spBlkPtr: SpBlockPtr): OSErr;
  321.     {$IFC NOT GENERATINGCFM}
  322.     INLINE $205F, $702C, $A06E, $3E80;
  323.     {$ENDC}
  324. FUNCTION SGetDriver(spBlkPtr: SpBlockPtr): OSErr;
  325.     {$IFC NOT GENERATINGCFM}
  326.     INLINE $205F, $702D, $A06E, $3E80;
  327.     {$ENDC}
  328. FUNCTION SPtrToSlot(spBlkPtr: SpBlockPtr): OSErr;
  329.     {$IFC NOT GENERATINGCFM}
  330.     INLINE $205F, $702E, $A06E, $3E80;
  331.     {$ENDC}
  332. FUNCTION SFindSInfoRecPtr(spBlkPtr: SpBlockPtr): OSErr;
  333.     {$IFC NOT GENERATINGCFM}
  334.     INLINE $205F, $702F, $A06E, $3E80;
  335.     {$ENDC}
  336. FUNCTION SFindSRsrcPtr(spBlkPtr: SpBlockPtr): OSErr;
  337.     {$IFC NOT GENERATINGCFM}
  338.     INLINE $205F, $7030, $A06E, $3E80;
  339.     {$ENDC}
  340. FUNCTION SDeleteSRTRec(spBlkPtr: SpBlockPtr): OSErr;
  341.     {$IFC NOT GENERATINGCFM}
  342.     INLINE $205F, $7031, $A06E, $3E80;
  343.     {$ENDC}
  344. FUNCTION OpenSlot(paramBlock: ParmBlkPtr; async: BOOLEAN): OSErr;
  345. FUNCTION OpenSlotSync(paramBlock: ParmBlkPtr): OSErr;
  346.     {$IFC NOT GENERATINGCFM}
  347.     INLINE $205F, $A200, $3E80;
  348.     {$ENDC}
  349. FUNCTION OpenSlotAsync(paramBlock: ParmBlkPtr): OSErr;
  350.     {$IFC NOT GENERATINGCFM}
  351.     INLINE $205F, $A600, $3E80;
  352.     {$ENDC}
  353. {  Device Manager Slot Support  }
  354. FUNCTION SIntInstall(sIntQElemPtr: SQElemPtr; theSlot: INTEGER): OSErr;
  355.     {$IFC NOT GENERATINGCFM}
  356.     INLINE $301F, $205F, $A075, $3E80;
  357.     {$ENDC}
  358. FUNCTION SIntRemove(sIntQElemPtr: SQElemPtr; theSlot: INTEGER): OSErr;
  359.     {$IFC NOT GENERATINGCFM}
  360.     INLINE $301F, $205F, $A076, $3E80;
  361.     {$ENDC}
  362. FUNCTION SVersion(spBlkPtr: SpBlockPtr): OSErr;
  363.     {$IFC NOT GENERATINGCFM}
  364.     INLINE $205F, $7008, $A06E, $3E80;
  365.     {$ENDC}
  366. FUNCTION SetSRsrcState(spBlkPtr: SpBlockPtr): OSErr;
  367.     {$IFC NOT GENERATINGCFM}
  368.     INLINE $205F, $7009, $A06E, $3E80;
  369.     {$ENDC}
  370. FUNCTION InsertSRTRec(spBlkPtr: SpBlockPtr): OSErr;
  371.     {$IFC NOT GENERATINGCFM}
  372.     INLINE $205F, $700A, $A06E, $3E80;
  373.     {$ENDC}
  374. FUNCTION SGetSRsrc(spBlkPtr: SpBlockPtr): OSErr;
  375.     {$IFC NOT GENERATINGCFM}
  376.     INLINE $205F, $700B, $A06E, $3E80;
  377.     {$ENDC}
  378. FUNCTION SGetTypeSRsrc(spBlkPtr: SpBlockPtr): OSErr;
  379.     {$IFC NOT GENERATINGCFM}
  380.     INLINE $205F, $700C, $A06E, $3E80;
  381.     {$ENDC}
  382. FUNCTION SGetSRsrcPtr(spBlkPtr: SpBlockPtr): OSErr;
  383.     {$IFC NOT GENERATINGCFM}
  384.     INLINE $205F, $701D, $A06E, $3E80;
  385.     {$ENDC}
  386.  
  387. {$ALIGN RESET}
  388. {$POP}
  389.  
  390. {$SETC UsingIncludes := SlotsIncludes}
  391.  
  392. {$ENDC} {__SLOTS__}
  393.  
  394. {$IFC NOT UsingIncludes}
  395.  END.
  396. {$ENDC}
  397.